import { Controller } from "../../mvc/core/Controller";
import { Dispatcher } from "../../mvc/core/Dispatcher";
import { GuildEventName } from "../view/guild/GuildEventName";
import { EventName } from "../mvc/EventName";
import { NetDispatcher } from "../../mvc/core/NetDispatcher";
import { ServerCommand } from "../mvc/ServerCommand";
import { EPublicCommand } from "../../../Message/Command/EPublicCommand";
import { UpdateCode } from "../../component/gconst/UpdateCode";
import { MsgManager } from "../manager/MsgManager";
import { Language } from "../../../extend/language/Language";
import { DataEvent } from "../events/DataEvent";
import { GuildPartyRewardWindow } from "../view/guild/party/GuildPartyRewardWindow";
import { AttributeValue } from "../scene/player/AttributeValue";
import { AttributeTextType } from "../scene/player/type/AttributeTextType";
import { SGuildTreeRing } from "../../../Message/Game/SGuildTreeRing";
import { UiHintIconView } from "../view/uiIconBtn/UiHintIconView";
import { Alert } from "../../../com/mui/controls/Alert";
import { GuildTreeFightPanel } from "../view/guild/tree/GuildTreeFightPanel";
import { GuildTreeCountMoneyView } from "../view/guild/tree/GuildTreeCountMoneyView";
import { GameProxy } from "../mvc/GameProxy";
import { SGuildBeastInfo } from "../../../Message/Game/SGuildBeastInfo";
import { MessageBlock } from "../../../Framework/MQ/MessageBlock";
import { SGuildCallTogether } from "../../../Message/Game/SGuildCallTogether";
import { GuildCallTogetherWindow } from "../view/guild/callTogether/GuildCallTogetherWindow";
import { GuildCallTogetherIcon } from "../view/guild/callTogether/GuildCallTogetherIcon";
import { GModuleEvent } from "../mvc/GModuleEvent";
import { GuildInfoWindow } from "../view/guild/GuildInfoWindow";
import { SGuildInfo } from "../../../Message/Game/SGuildInfo";
import { SGuildPlayerAttendanceVo } from "../view/guild/resourceAllocation/vo/SGuildPlayerAttendanceVo";
import { AssignGuildWarehouseExVo } from "../view/guild/resourceAllocation/vo/AssignGuildWarehouseExVo";
import { SGuildWarehouseApply } from "../../../Message/Game/SGuildWarehouseApply";
import { SGuildWarehouseUpdate } from "../../../Message/Game/SGuildWarehouseUpdate";
import { GuildTreeFightAlertWindow } from "../view/guild/tree/GuildTreeFightAlertWindow";
import { GuildTreeFightIcon } from "../view/guild/tree/GuildTreeFightIcon";
import { IView } from "../../mvc/interfaces/IView";
import { GuildShowType } from "../view/guild/GuildShowType";
import { GuildModule } from "../../../modules/GuildModule";
import { GameController } from "../mvc/GameController";
import { BaseWindow } from "../../component/window/BaseWindow";
import { IGuildListModule } from "../../../modules/interfaces/IGuildListModule";
import { GuildListModule } from "../../../modules/GuildListModule";
import { WindowEvent } from "../../component/window/WindowEvent";
import { GameManager } from "../manager/GameManager";
import { ModuleType } from "../view/common/ModuleType";
import { SGuildPlan } from "../../../Message/Game/SGuildPlan";
import { GameConst } from "../../component/gconst/GameConst";
import { CreateGuildWindow } from "../view/guild/CreateGuildWindow";
import { SMiniGuildInfo } from "../../../Message/Game/SMiniGuildInfo";
import { GuildDetailWindow } from "../view/guild/GuildDetailWindow";
import { InviteListWindow } from "../view/guild/InviteListWindow";
import { NominateWindow } from "../view/guild/myGuild/NominateWindow";
import { GuildTaskWindow } from "../view/guild/GuildTaskWindow";
import { GuildContibuteWindow } from "../view/guild/GuildContibuteWindow";
import { GuildApplyListWindow } from "../view/guild/myGuild/GuildApplyListWindow";
import { GuildMassSendWindow } from "../view/guild/myGuild/GuildMassSendWindow";
import { SPublicMiniPlayer } from "../../../Message/Public/SPublicMiniPlayer";
import { GuildWelcomeNewMemberWindow } from "../view/guild/myGuild/GuildWelcomeNewMemberWindow";
import { GuildWelcomeListWindow } from "../view/guild/myGuild/GuildWelcomeListWindow";
import { EOperOption } from "../../../Message/Game/EOperOption";
import { StringHelper } from "../../../com/gengine/utils/StringHelper";
import { GameDefConfig } from "../resource/GameDefConfig";
import { EPrictUnit } from "../../../Message/Public/EPrictUnit";
import { SPlayerGuildInfo } from "../../../Message/Game/SPlayerGuildInfo";
import { InviteGuildRender } from "../view/guild/InviteGuildRender";
import { EGuildPosition } from "../../../Message/Game/EGuildPosition";
import { SGuildPlayer } from "../../../Message/Game/SGuildPlayer";
import { HTMLUtil } from "../../../com/gengine/utils/HTMLUtil";
import { HighlightManager } from "../manager/HighlightManager";
import { SGuildApplyNum } from "../../../Message/Game/SGuildApplyNum";
import { PulseSharedObject } from "../view/player/PulseSharedObject";
import { EChatType } from "../../../Message/Public/EChatType";
import { IGuildModule } from "../../../modules/interfaces/IGuildModule";
import { FilterText } from "../../../com/gengine/utils/FilterText";
import { GuildImpeachWindow } from "../view/guild/GuildImpeachWindow";
import { SGuildLeaderImpeach } from "../../../Message/Game/SGuildLeaderImpeach";
import { ClockManager } from "../manager/ClockManager";
import { GuildImpeachIconView } from "../view/guild/GuildImpeachIconView";
import { GuildRefuteImpeachWindow } from "../view/guild/GuildRefuteImpeachWindow";
import { GuildPartyWindow } from "../view/guild/party/GuildPartyWindow";
import { SGuildPartyOpen } from "../../../Message/Game/SGuildPartyOpen";
import { GuildPartyJoinWindow } from "../view/guild/party/GuildPartyJoinWindow";
import { GuildPartyDescWindow } from "../view/guild/party/GuildPartyDescWindow";
import { LayerManager } from "../manager/LayerManager";
import { GuildPartyInfo } from "../view/guild/info/GuildPartyInfo";
import { EGuildPartyType } from "../../../Message/Game/EGuildPartyType";
import { GuildPartyResultPanel } from "../view/guild/party/GuildPartyResultPanel";
import { GuildPartyIconView } from "../view/guild/party/GuildPartyIconView";
import { SGuildPartyHot } from "../../../Message/Game/SGuildPartyHot";
import { ExpAddInfo } from "../view/effect/ExpAddInfo";
import { GuildUtil } from "../view/guild/info/GuildUtil";
import { GuildRaiseContributeWindow } from "../view/guild/party/GuildRaiseContributeWindow";
import { GuildPartyDiscountInfo } from "../view/guild/info/GuildPartyDiscountInfo";
import { SMoney } from "../../../Message/Game/SMoney";
import { IGuildPartyModule } from "../../../modules/interfaces/IGuildPartyModule";
import { WelcomeHintIcon } from "../view/guild/myGuild/WelcomeHintIcon";
import { Guild } from "../../../ModuleType/Guild";
type int = number;
//class GuildController
    
    export  class GuildController extends Controller
    {
        constructor()
        {
            
            super();Dispatcher.addEventListener(GuildEventName.OpenCreateGuildWindow, this.onOpenCreateGuildWindowHandler);
            Dispatcher.addEventListener(GuildEventName.OpenSeeGuildWindow, this.onOpenSeeGuildWindowHandler);
            Dispatcher.addEventListener(GuildEventName.OpenGuildInviteListWindow, this.onOpenGuildInviteListWindowHandler);
            Dispatcher.addEventListener(GuildEventName.OpenGuildNominateWindow, this.onOpenGuildNominateWindowHandler);
            Dispatcher.addEventListener(GuildEventName.OpenGuildTaskGuideWindow, this.onOpenGuildTaskGuideWindowHandler);
            Dispatcher.addEventListener(GuildEventName.OpenGuildContriWindow, this.onOpenGuildContriWindowHandler);
            Dispatcher.addEventListener(GuildEventName.OpenGuildApplyListWindow, this.onOpenGuildApplyListWindowHandler);
            Dispatcher.addEventListener(GuildEventName.SortMember, this.onSortMemberHandler);
            Dispatcher.addEventListener(GuildEventName.OpenMassSendWindow, this.onOpenMassSendWindowHandler);
            Dispatcher.addEventListener(GuildEventName.OpenWelcomeNewMemberWindow, this.onOpenWelcomeNewMemberWindowHandler);
            Dispatcher.addEventListener(GuildEventName.OpenWelcomeListWindow, this.onOpenWelcomeListWindowHandler);
            Dispatcher.addEventListener(GuildEventName.AutoSelectedMember, this.onAutoSelectedMemberHandler);
            Dispatcher.addEventListener(EventName.GuildModuleOpen, this.onGuildModuleOpenHandler);
            Dispatcher.addEventListener(EventName.GuildInfoWindowOpen, this.onGuildInfoWindowOpenHandler);
            Dispatcher.addEventListener(EventName.OpenGuildWindow, this.onOpenGuildWindowHandler);
            Dispatcher.addEventListener(EventName.GuildListWindowOpen, this.onGuildListWindowOpenHandler);
            Dispatcher.addEventListener(EventName.CloseGuildWindow, this.onCloseGuildWindowHandler);
            Dispatcher.addEventListener(EventName.GuildCreate, this.onGuildCreateHandler);
            Dispatcher.addEventListener(EventName.GuildCreateSuccess, this.onGuildCreateSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildGetInfo, this.onGuildGetHandler);
            Dispatcher.addEventListener(EventName.GuildGetInfoSuccess, this.onGuildGetInfoSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildGetMyInfoSuccess, this.onGuildGetMyInfoSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildSearch, this.onGuildSearchHandler);
            Dispatcher.addEventListener(EventName.GuildSearchSuccess, this.onGuildSearchSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildApply, this.onGuildApplyHandler);
            Dispatcher.addEventListener(EventName.GuildApplySuccess, this.onGuildApplySuccessHandler);
            Dispatcher.addEventListener(EventName.GuildCancelApply, this.onGuildCancelApplyHandler);
            Dispatcher.addEventListener(EventName.GuildCancelApplySuccess, this.onGuildCancelApplySuccessHandler);
            Dispatcher.addEventListener(EventName.GuildDealApply, this.onGuildDealApplyHandler);
            Dispatcher.addEventListener(EventName.GuildDealApplySuccess, this.onGuildDealApplySuccessHandler);
            Dispatcher.addEventListener(EventName.GuildGetApplyList, this.onGuildGetApplyListHandler);
            Dispatcher.addEventListener(EventName.GuildGetApplyListSuccess, this.onGuildGetApplyListSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildGetPlayerList, this.onGuildGetPlayerListHandler);
            Dispatcher.addEventListener(EventName.GuildGetPlayerListSuccess, this.onGuildGetPlayerListSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildInvite, this.onGuildInviteHandler);
            Dispatcher.addEventListener(EventName.GuildInviteSuccess, this.onGuildInviteSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildDealInvite, this.onGuildDealInviteHandler);
            Dispatcher.addEventListener(EventName.GuildDealInviteSuccess, this.onGuildDealInviteSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildMemberOper, this.onGuildGuildMemberOperHandler);
            Dispatcher.addEventListener(EventName.GuildMemberOperSuccess, this.onGuildMemberOperSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildChangePurpose, this.onGuildChangePurposeHandler);
            Dispatcher.addEventListener(EventName.GuildChangePurposeSuccess, this.onGuildChangePurposeSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildChangeYYQQ, this.onGuildChangeYYQQHandler);
            Dispatcher.addEventListener(EventName.GuildChangeYYQQSuccess, this.onGuildChangeYYQQSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildNominate, this.onGuildNominateHandler);
            Dispatcher.addEventListener(EventName.GuildNominateSuccess, this.onGuildNominateSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildKickOut, this.onGuildKickOutHandler);
            Dispatcher.addEventListener(EventName.GuildKickOutSuccess, this.onGuildKickOutSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildQuit, this.onGuildQuitHandler);
            Dispatcher.addEventListener(EventName.GuildQuitSuccess, this.onGuildQuitSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildDisband, this.onGuildDisbandHandler);
            Dispatcher.addEventListener(EventName.GuildDisbandSuccess, this.onGuildDisbandSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildApplyPlayersGuild, this.onGuildApplyPlayersGuildHandler);
            Dispatcher.addEventListener(EventName.GuildApplyPlayersGuildSuccess, this.onGuildApplyPlayersGuildSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildUpdate, this.onGuildUpdateHandler);
            Dispatcher.addEventListener(EventName.GuildUpdateSuccess, this.onGuildUpdateSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildDonateMoney, this.onGuildDonateMoneyHandler);
            Dispatcher.addEventListener(EventName.GuildDonateMoneySuccess, this.onGuildDonateMoneySuccessHandler);
            Dispatcher.addEventListener(EventName.GuildSendMail, this.onGuildSendMailHandler);
            Dispatcher.addEventListener(EventName.GuildSendMailSuccess, this.onGuildSendMailSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildSendChat, this.onGuildSendChatHandler);
            Dispatcher.addEventListener(EventName.GuildSendChatSuccess, this.onGuildSendChatSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildSendWelcome, this.onGuildSendWelcomeHandler);
            Dispatcher.addEventListener(EventName.GuildSendWelcomeSuccess, this.onGuildSendWelcomeSuccessHandler);
            NetDispatcher.addCmdListener(ServerCommand.GuildWarPlayerTopListUpdate, this.onPlayerTopListUpdate);
            NetDispatcher.addCmdListener(ServerCommand.GuildWarGuildTopListUpdate, this.onGuildTopListUpdate);
            Dispatcher.addEventListener(EventName.GuildUpdateName, this.onGuildUpdateNameHandler);
            Dispatcher.addEventListener(EventName.GuildUpdateNameSuccess, this.onGuildUpdateNameSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildUpgradeRoom, this.onGuildUpgradeRoomHandler);
            Dispatcher.addEventListener(EventName.GuildImpeachWindowOpen, this.onGuildImpeachWindowOpenHandler);
            Dispatcher.addEventListener(EventName.GuildGetCanImpeach, this.onGuildGetCanImpeachHandler);
            Dispatcher.addEventListener(EventName.GuildGetCanImpeachSuccess, this.onGuildGetCanImpeachSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildImpeachLeader, this.onGuildImpeachLeaderHandler);
            Dispatcher.addEventListener(EventName.GuildImpeachLeaderSuccess, this.onGuildImpeachLeaderSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildRefuteImpeach, this.onGuildRefuteImpeachHandler);
            Dispatcher.addEventListener(EventName.GuildRefuteImpeachSuccess, this.onGuildRefuteImpeachSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildRefuteImpeachWindowOpen, this.onGuildRefuteImpeachWindowOpenHandler);
            NetDispatcher.addCmdListener(ServerCommand.GuildImpeachLeaderCommand, this.onGuildImpeachLeaderCommandHandler);
            NetDispatcher.addCmdListener(EPublicCommand._ECmdPublicGuildLeaderImpeachEnd, this.onGuildLeaderImpeachEndHandler);
            Dispatcher.addEventListener(EventName.GuildPartyWindowOpen, this.onGuildPartyWindowOpenHandler);
            Dispatcher.addEventListener(EventName.GuildPartyJoinWindowOpen, this.onGuildPartyJoinWindowOpenHandler);
            Dispatcher.addEventListener(EventName.GuildPartyDescWindowOpen, this.onGuildPartyDescWindowOpenHandler);
            Dispatcher.addEventListener(EventName.GuildGetPartyInfo, this.onGuildGetPartyInfoHandler);
            Dispatcher.addEventListener(EventName.GuildGetPartyInfoSuccess, this.onGuildGetPartyInfoSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildBookParty, this.onGuildBookPartyHandler);
            Dispatcher.addEventListener(EventName.GuildBookPartySuccess, this.onGuildBookPartySuccessHandler);
            Dispatcher.addEventListener(EventName.GuildPartyRaiseContributeOpen, this.onGuildPartyRaiseContributeOpenHandler);
            Dispatcher.addEventListener(EventName.GuildPartyRaiseContribute, this.onGuildPartyRaiseContributeHandler);
            Dispatcher.addEventListener(EventName.GuildPartyRaiseContributeSuccess, this.onGuildPartyRaiseContributeSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildPartyGetDiscount, this.onGuildPartyGetDiscountHandler);
            Dispatcher.addEventListener(EventName.GuildPartyGetDiscountSuccess, this.onGuildPartyGetDiscountSuccessHandler);
            Dispatcher.addEventListener(EventName.GuildPartyContriAdd, this.onGuildPartyContriAddHandler);
            Dispatcher.addEventListener(EventName.GuildPartyRewardWindowOpen, this.onGuildPartyRewardWindowOpenHandler);
            NetDispatcher.addCmdListener(ServerCommand.GuildPartyOpenCommand, this.onGuildPartyOpenCommandHandler);
            NetDispatcher.addCmdListener(ServerCommand.GuildPartyCloseCommand, this.onGuildPartyCloseCommandHandler);
            NetDispatcher.addCmdListener(ServerCommand.GuildPartyHotCommand, this.onGuildPartyHotCommandHandler);
            NetDispatcher.addCmdListener(ServerCommand.RoleExpAdd, this.onRoleExpAddHandler);
            NetDispatcher.addCmdListener(ServerCommand.GuildPartyAuraAddCommand, this.onGuildPartyAuraAddCommandHandler);
            NetDispatcher.addCmdListener(ServerCommand.GuildPartyContributeAddCommand, this.onGuildPartyContributeAddCommandHandler);
            NetDispatcher.addCmdListener(ServerCommand.GuildTreeWormCommand, this.onGuildTreeWormCommandHandler);
            NetDispatcher.addCmdListener(ServerCommand.GuildTreeRipeCommand, this.onGuildTreeRipeCommandHandler);
            NetDispatcher.addCmdListener(ServerCommand.GuildTreeCoinBindAddCommand, this.onGuildTreeCoinBindAddCommandHandler);
            Dispatcher.addEventListener(EventName.GuildManorEnterInto, this.onGuildManorEnterIntoHandler);
            Dispatcher.addEventListener(EventName.GuildManorLeave, this.onGuildManorLeaveHandler);
            Dispatcher.addEventListener(EventName.TaskTrackShowOrHide, this.onTaskTrackShowOrHideHandler);
            Dispatcher.addEventListener(EventName.GuildTreeFightAlertWindowClose, this.onGuildTreeFightAlertWindowCloseHandler);
            Dispatcher.addEventListener(EventName.StageResize, this.onStageResizeHandler);
            Dispatcher.addEventListener(EventName.GuildActivityGetInfo, this.onGuildActivityGetInfoHandler);
            NetDispatcher.addCmdListener(EPublicCommand._ECmdPublicGuildCallTogether, this.onReceiveGuildCallTogether);
            NetDispatcher.addCmdListener(EPublicCommand._ECmdPublicGuildCallTogetherSuccess, this.onGuildCallTogetherSuccess);
            Dispatcher.addEventListener(EventName.GetGuildWarehouseRecordsSucceed, this.onGetGuildWarehouseRecordsSucceed);
            Dispatcher.addEventListener(EventName.GuildWarehouseGetItemsSuccess, this.onGuildWarehouseGetItemsSuccessHandler);
            Dispatcher.addEventListener(EventName.ConfirmAssignGuildWarehouseEx, this.onConfirmAssignGuildWarehouseEx);
            Dispatcher.addEventListener(EventName.GuildWarehouseGetAllApplySuccess, this.onGuildWarehouseGetAllApplySuccessHandler);
            Dispatcher.addEventListener(EventName.GuildWarehouseReplySuccess, this.onGuildWarehouseReplySuccessHandler);
            Dispatcher.addEventListener(EventName.AssignGuildWarehouseExSucceed, this.onAssignGuildWarehouseExSucceed);
            NetDispatcher.addCmdListener(ServerCommand.GuildWarehouseUpdateCommand, this.onGuildWarehouseUpdateCommandHandler);
            Dispatcher.addEventListener(EventName.GuildUnionInfoChange, this.onGuildUnionInfoChangeHandler);
            Dispatcher.addEventListener(EventName.GuildUnionAppleListChange, this.onGuildUnionInviteListChangeHandler);
            Dispatcher.addEventListener(EventName.GuildStrategyChange, this.onGuildStrategyChangeHandler);
            Dispatcher.addEventListener(EventName.GuildPlanChange, this.onGuildPlanChangeHandler);
            return;
        }

        /* internal  */onGuildPartyAuraAddCommandHandler(arg1: Object): void
        {
            var loc1=arg1.updateCode;
            var loc2=arg1.aura;
            cache.guild.guildPartyTotalAura = cache.guild.guildPartyTotalAura + loc2;
            if (this._guildPartyResultPanel) 
            {
                this._guildPartyResultPanel.updateAura(cache.guild.guildPartyTotalAura);
            }
            if (loc1 == UpdateCode.EUpdateCodeGuildPartyFood) 
            {
                MsgManager.showRollTipsMsg(Language.getStringByParam(57456, loc2));
            }
            return;
        }

        /* internal  */onGuildPartyContriAddHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as int;
            cache.guild.guildPartyTotalContribute = cache.guild.guildPartyTotalContribute + loc1;
            if (this._guildPartyResultPanel) 
            {
                this._guildPartyResultPanel.updateContri(cache.guild.guildPartyTotalContribute);
            }
            return;
        }

        /* internal  */onGuildPartyRewardWindowOpenHandler(arg1: DataEvent): void
        {
            if (!this._partyRewardWindow) 
            {
                this._partyRewardWindow = new GuildPartyRewardWindow();
            }
            this._partyRewardWindow.show();
            return;
        }

        /* internal  */onGuildPartyContributeAddCommandHandler(arg1: int): void
        {
            cache.guild.guildTreeTotalContribute = cache.guild.guildTreeTotalContribute + arg1;
            if (this._guildTreeWormPanel) 
            {
                this._guildTreeWormPanel.updateContribute(cache.guild.guildTreeTotalContribute);
            }
            NetDispatcher.dispatchCmd(ServerCommand.RoleSingleAttributeChange, new AttributeValue(AttributeTextType.contribution, true, arg1));
            return;
        }

        /* internal  */onGuildTreeWormCommandHandler(arg1: SGuildTreeRing): void
        {
            if (cache.guild.isInSelfManorMap()) 
            {
                this.showGuildTreeWormPanel(arg1);
            }
            this._guildTreeType = 0;
            if (!this.guildTreeFightIcon.parent) 
            {
                UiHintIconView.instance.addHintIcon(this.guildTreeFightIcon);
            }
            if (arg1 == null) 
            {
                if (this.guildTreeFightIcon.parent) 
                {
                    UiHintIconView.instance.removeHintIcon(this.guildTreeFightIcon);
                }
            }
            return;
        }

        /* internal  */onGuildTreeRipeCommandHandler(arg1: SGuildTreeRing): void
        {
            this._guildTreeType = 1;
            UiHintIconView.instance.addHintIcon(this.guildTreeFightIcon);
            if (cache.guild.isInSelfManorMap()) 
            {
                this.showGuildTreeCountMoneyView(arg1);
            }
            if (arg1 == null) 
            {
                if (this._guildTreeFightIcon && this._guildTreeFightIcon.parent) 
                {
                    UiHintIconView.instance.removeHintIcon(this._guildTreeFightIcon);
                }
            }
            return;
        }

        /* internal  */onGuildManorEnterIntoHandler(arg1: DataEvent): void
        {
            if (cache.guild.guildTreeWormRing) 
            {
                this.showGuildTreeWormPanel(cache.guild.guildTreeWormRing);
            }
            if (cache.guild.guildTreeMoneyRing) 
            {
                this.showGuildTreeCountMoneyView(cache.guild.guildTreeMoneyRing);
            }
            return;
        }

        /* internal  */onGuildManorLeaveHandler(arg1: DataEvent): void
        {
            this.tallyUpGuildParty();
            this.tallyUpGuildTreeWorm();
            this.tallyUpGuildTreeMoney();
            if (this._guildTreeWormPanel) 
            {
                this._guildTreeWormPanel.hide();
            }
            if (this._countMoneyView) 
            {
                this._countMoneyView.hide();
            }
            return;
        }

        /* internal  */tallyUpGuildTreeWorm(): void
        {
            var loc1=cache.guild.guildTreeWormTotalExp;
            var loc2=cache.guild.guildTreeTotalContribute;
            if (loc1 > 0 || loc2 > 0) 
            {
                Alert.show(Language.getStringByParam(57495, loc1, loc2), null, Alert.OK, null);
            }
            cache.guild.guildTreeWormTotalExp = 0;
            cache.guild.guildTreeTotalContribute = 0;
            if (this._guildTreeWormPanel) 
            {
                this._guildTreeWormPanel.updateExp(0);
                this._guildTreeWormPanel.updateContribute(0);
            }
            return;
        }

        /* internal  */tallyUpGuildTreeMoney(): void
        {
            var loc1=cache.guild.guildTreeTotalCoinBind;
            if (loc1 > 0) 
            {
                Alert.show(Language.getStringByParam(57496, loc1), null, Alert.OK, null);
            }
            cache.guild.guildTreeTotalCoinBind = 0;
            return;
        }

        /* internal  */showGuildTreeWormPanel(arg1: SGuildTreeRing): void
        {
            var loc1=false;
            if (arg1) 
            {
                if (this._guildTreeWormPanel == null) 
                {
                    this._guildTreeWormPanel = new GuildTreeFightPanel();
                }
                this._guildTreeWormPanel.updateByTreeRing(arg1);
                this._guildTreeWormPanel.show();
                loc1 = false;
            }
            else 
            {
                if (this._guildTreeWormPanel) 
                {
                    this._guildTreeWormPanel.hide();
                }
                loc1 = true;
                this.tallyUpGuildTreeWorm();
            }
            Dispatcher.dispatchEvent(new DataEvent(EventName.TaskTrackShowOrHide, loc1));
            return;
        }

        /* internal  */onTaskTrackShowOrHideHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as Boolean;
            if (this._guildTreeWormPanel != null) 
            {
                this._guildTreeWormPanel.showThis(!loc1);
            }
            return;
        }

        /* internal  */showGuildTreeCountMoneyView(arg1: SGuildTreeRing): void
        {
            if (arg1) 
            {
                if (this._countMoneyView == null) 
                {
                    this._countMoneyView = new GuildTreeCountMoneyView();
                }
                this._countMoneyView.setRing(arg1.shakeNum, arg1.maxRing);
                this._countMoneyView.show();
            }
            else if (this._countMoneyView) 
            {
                this._countMoneyView.hide();
            }
            return;
        }

        /* internal  */onGuildTreeCoinBindAddCommandHandler(arg1: int): void
        {
            cache.guild.guildTreeTotalCoinBind = cache.guild.guildTreeTotalCoinBind + arg1;
            if (this._countMoneyView != null) 
            {
                this._countMoneyView.updateRingBottleMoney();
            }
            return;
        }

        /* internal  */onGuildTreeIconClickHandler(arg1: Object /* flash.events.Event */): void
        {
            if (this._guildTreeType != 0) 
            {
                if (this._guildTreeType == 1) 
                {
                    this.guildTreeFightAlertWindow.updateTip(Language.getString(57618));
                }
            }
            else 
            {
                this.guildTreeFightAlertWindow.updateTip(Language.getString(57494));
            }
            this.guildTreeFightAlertWindow.show();
            return;
        }

        /* internal  */onGuildTreeFightAlertWindowCloseHandler(arg1: DataEvent): void
        {
            if (cache.guild.guildTreeWormRing) 
            {
                if (!this.guildTreeFightIcon.parent) 
                {
                    UiHintIconView.instance.addHintIcon(this.guildTreeFightIcon);
                }
            }
            return;
        }

        /* internal  */onStageResizeHandler(arg1: DataEvent): void
        {
            if (this._countMoneyView) 
            {
                this._countMoneyView.stageResize();
            }
            if (this._guildTreeWormPanel) 
            {
                this._guildTreeWormPanel.stageResize();
            }
            return;
        }

        /* internal  */onGuildActivityGetInfoHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as int;
            GameProxy.guildProxy.getGuildActivityInfo(loc1);
            return;
        }

        /* internal  */onGuildAnimalInfoCommandHandler(arg1: SGuildBeastInfo): void
        {
            if (this._guildModule) 
            {
                this._guildModule.updateAnimalPanel(arg1);
            }
            return;
        }

        /* internal  */onReceiveGuildCallTogether(arg1: MessageBlock): void
        {
            var loc1=arg1.messageBase as SGuildCallTogether;
            if (!this._guildCallTogetherWindow) 
            {
                this._guildCallTogetherWindow = new GuildCallTogetherWindow();
                this._guildCallTogetherWindow.addEventListener(GuildCallTogetherWindow.DoMinimize, this.onCallTogetherWinMinimize);
            }
            this._guildCallTogetherWindow.addGatherInfo(loc1);
            this._guildCallTogetherWindow.show();
            return;
        }

        /* internal  */onGuildCallTogetherSuccess(arg1): void
        {
            MsgManager.showRollTipsMsg(Language.getString(60758));
            return;
        }

        /* internal  */onCallTogetherWinMinimize(arg1): void
        {
            if (!this._guildCallTogetherIcon) 
            {
                this._guildCallTogetherIcon = new GuildCallTogetherIcon();
                this._guildCallTogetherIcon.addEventListener(GModuleEvent.Guild_CallTogetherIconClick, this.onCallTogetherIconClick);
            }
            UiHintIconView.instance.addHintIcon(this._guildCallTogetherIcon, false);
            return;
        }

        /* internal  */onGuildInfoWindowOpenHandler(arg1: DataEvent): void
        {
            var e: DataEvent;
            var guildId: int;

            var loc1;
            e = arg1;
            guildId = e.data as int;
            if (this._infoWindow == null) 
            {
                this._infoWindow = new GuildInfoWindow();
            }
            this._infoWindow.show();
            GameProxy.guildProxy.getGuildInfo(guildId, (arg1: SGuildInfo): void
            {
                _infoWindow.updateBySGuildInfo(arg1);
                return;
            })
            this._infoWindow.showApplyButton(cache.guild.myGuildInfo == null);
            return;
        }

        /* internal  */onCallTogetherIconClick(arg1): void
        {
            UiHintIconView.instance.removeHintIcon(this._guildCallTogetherIcon);
            this._guildCallTogetherWindow.show();
            return;
        }

        /* internal  */onGetGuildWarehouseRecordsSucceed(arg1: DataEvent): void
        {
            var loc1=null;
            var loc2=null;
            var loc3=null;
            var loc4=null;
            cache.guild.resourceDistributeList = arg1.data as Array<any>;
            if (this._guildModule) 
            {
                loc1 = arg1.data as Array<any>;
                loc2 = [];
                var loc5=0;
                var loc6=loc1;
                for(loc4 of loc6) 
                {
                    (loc3 = new SGuildPlayerAttendanceVo()).itemData = loc4;
                    loc3.isSelect = false;
                    loc2.push(loc3);
                }
                this._guildModule.setGuildWarehouseRecordsList(loc2);
            }
            return;
        }

        /* internal  */onAssignGuildWarehouseExSucceed(arg1: DataEvent): void
        {
            if (this._guildModule) 
            {
                this._guildModule.assignGuildWarehouseExSucceed();
            }
            return;
        }

        /* internal  */onConfirmAssignGuildWarehouseEx(arg1: DataEvent): void
        {
            var loc1=arg1.data.vo as AssignGuildWarehouseExVo;
            GameProxy.guildProxy.assignGuildWarehouseEx(loc1);
            return;
        }

        /* internal  */onGuildWarehouseGetAllApplySuccessHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as Array<any>;
            if (this._guildModule) 
            {
                this._guildModule.setGuildWarehouseReplyList(loc1);
            }
            return;
        }

        /* internal  */onGuildWarehouseReplySuccessHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data["applyInfo"] as SGuildWarehouseApply;
            var loc2=arg1.data["result"] as Boolean;
            if (loc2) 
            {
                MsgManager.showRollTipsMsg(Language.getString(57381));
            }
            else 
            {
                MsgManager.showRollTipsMsg(Language.getString(57382));
            }
            this._guildModule.removeReplyedApply(loc1);
            return;
        }

        /* internal  */onGuildWarehouseGetItemsSuccessHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data["itemsArray"] as Array<any>;
            var loc2=arg1.data["moneyMap"] as Map<any, any> /* flash.utils.Dictionary */;
            if (this._guildModule) 
            {
                this._guildModule.setGuildWarehouseItems(loc1);
                this._guildModule.setGuildWarehouseMoney(loc2);
            }
            return;
        }

        /* internal  */onGuildWarehouseUpdateCommandHandler(arg1: SGuildWarehouseUpdate): void
        {
            var loc1=arg1.items;
            if (this._guildModule) 
            {
                this._guildModule.setGuildWarehouseItems(loc1);
                this._guildModule.setGuildWarehouseMoney(arg1.moneyMap);
            }
            return;
        }

        /* internal  */onGuildUnionInfoChangeHandler(arg1: DataEvent): void
        {
            if (this._guildModule) 
            {
                this._guildModule.updateGuildUnionInfo(cache.guildUnion.myGuildUnionInfo);
            }
            return;
        }

        /* internal  */onGuildUnionInviteListChangeHandler(arg1: DataEvent): void
        {
            if (this._guildModule) 
            {
                this._guildModule.updateGuildUnionApplyBtnStatus();
            }
            return;
        }

        /* internal  */onGuildStrategyChangeHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as string;
            GameProxy.guildProxy.changeGuildStrategy(loc1);
            return;
        }

        public get guildTreeFightAlertWindow(): GuildTreeFightAlertWindow
        {
            if (this._guildTreeFightAlertWindow == null) 
            {
                this._guildTreeFightAlertWindow = new GuildTreeFightAlertWindow();
            }
            return this._guildTreeFightAlertWindow;
        }

        public get guildTreeFightIcon(): GuildTreeFightIcon
        {
            if (this._guildTreeFightIcon == null) 
            {
                this._guildTreeFightIcon = new GuildTreeFightIcon();
                this._guildTreeFightIcon.addEventListener(flash.events.MouseEvent.CLICK, this.onGuildTreeIconClickHandler);
            }
            return this._guildTreeFightIcon;
        }

        public /* override */ get view(): IView
        {
            return this.initView();
        }

        protected /* override */ initView(): IView
        {
            if (cache.guild.myGuildInfo) 
            {
                GuildController.curShowType = GuildShowType.MyGuildList;
                if (null == this._guildModule) 
                {
                    this._guildModule = new GuildModule();
                    this._guildModule.addEventListener(flash.events.Event.ADDED_TO_STAGE, this.onAddedToStageHandler);
                }
                GameController.guildManor.init();
                return this._guildModule;
            }
            GuildController.curShowType = GuildShowType.NormalGuildList;
            return this.guildListModule;
        }

        public get guildContentSprite(): Object /* flash.display.DisplayObject */
        {
            return (this.view as BaseWindow).contentContainer;
        }

        public get guildListModule(): IGuildListModule
        {
            GuildController.curShowType = GuildShowType.NormalGuildList;
            if (null == this._guildListModule) 
            {
                this._guildListModule = new GuildListModule();
                this._guildListModule.addEventListener(flash.events.Event.ADDED_TO_STAGE, this.onAddedToStageHandler);
                this._guildListModule.addEventListener(WindowEvent.CLOSE, this.onGuildWindowCloseHandler);
            }
            return this._guildListModule;
        }

        /* internal  */onAddedToStageHandler(arg1: Object /* flash.events.Event */): void
        {
            var loc1=false;
            if (GuildController.curShowType != GuildShowType.NormalGuildList) 
            {
                Dispatcher.dispatchEvent(new DataEvent(EventName.GuildGetInfo, 0));
                if (this._guildModule != null) 
                {
                    this._guildModule.updatePlayerGuildInfoPanel(cache.guild.myGuildInfo);
                }
                Dispatcher.dispatchEvent(new DataEvent(GuildEventName.GuildModuleShow));
            }
            else 
            {
                loc1 = this._guildListModule != null ? this._guildListModule.isFull() : true;
                Dispatcher.dispatchEvent(new DataEvent(EventName.GuildSearch, {"camp": 0, "guildName":"", "isFull": loc1}));
            }
            Dispatcher.dispatchEvent(new DataEvent(EventName.GuildWindowShow));
            return;
        }

        /* internal  */onGuildWindowCloseHandler(arg1: WindowEvent): void
        {
            Dispatcher.dispatchEvent(new DataEvent(EventName.GuildListWindowClose));
            return;
        }

        protected /* override */ initServer(): void
        {
            NetDispatcher.addCmdListener(ServerCommand.GuildUpdateInfo, this.onGuildUpdateInfoHandler);
            NetDispatcher.addCmdListener(ServerCommand.GuildPushInviteInfo, this.onGuildPushInviteInfoHandler);
            NetDispatcher.addCmdListener(ServerCommand.GuildNewApply, this.onGuildNewApplyHandler);
            NetDispatcher.addCmdListener(ServerCommand.GuildWelcome, this.onGuildWelcomeHandler);
            NetDispatcher.addCmdListener(ServerCommand.GuildNewMember, this.onGuildNewMemberHandler);
            NetDispatcher.addCmdListener(ServerCommand.BackpackDataChange, this.onPackbagChangeHandler);
            NetDispatcher.addCmdListener(ServerCommand.BackPackItemsChange, this.onPackbagChangeHandler);
            NetDispatcher.addCmdListener(ServerCommand.MoneyUpdate, this.onMoneyUpdateHandler);
            NetDispatcher.addCmdListener(ServerCommand.GuildAnimalInfoCommand, this.onGuildAnimalInfoCommandHandler);
            return;
        }

        /* internal  */onOpenGuildWindowHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as int;
            if (cache.guild.myGuildInfo) 
            {
                if (this._guildModule == null) 
                {
                    this._guildModule = this.view as GuildModule;
                }
                GameController.guildManor.init();
                if (!cache.country.isOpenCountry) 
                {
                    this._guildModule.show();
                }
                this._guildModule.showTabByIndex(loc1);
            }
            return;
        }

        /* internal  */onGuildModuleOpenHandler(arg1: DataEvent): void
        {
            if (cache.country.isOpenCountry) 
            {
                GameManager.instance.popupWindow(ModuleType.Guild);
            }
            else if (cache.guild.myGuildInfo) 
            {
                this.view.show();
            }
            else 
            {
                this.onGuildListWindowOpenHandler(null);
            }
            return;
        }

        /* internal  */onGuildPlanChangeHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as SGuildPlan;
            GameProxy.guildProxy.changeGuildPlan(loc1);
            return;
        }

        /* internal  */onGuildListWindowOpenHandler(arg1: DataEvent): void
        {
            GuildController.curShowType = GuildShowType.NormalGuildList;
            if (cache.country.isOpenCountry) 
            {
                GameManager.instance.popupWindow(ModuleType.Guild);
            }
            else 
            {
                this.guildListModule.show();
            }
            return;
        }

        /* internal  */onCloseGuildWindowHandler(arg1: DataEvent): void
        {
            if (this._guildModule && this._guildModule.isHide == false) 
            {
                this._guildModule.hide();
            }
            return;
        }

        /* internal  */onOpenCreateGuildWindowHandler(arg1: DataEvent): void
        {
            if (cache.role.entityInfo.level < GameConst.GuildCreatePlayerLevel) 
            {
                MsgManager.showRollTipsMsg(Language.getStringByParam(57338, GameConst.GuildCreatePlayerLevel));
                return;
            }
            if (cache.guild.myGuildInfo) 
            {
                MsgManager.showRollTipsMsg(Language.getString(57392));
                return;
            }
            if (this._createWindow == null) 
            {
                this._createWindow = new CreateGuildWindow();
            }
            this._createWindow.show();
            return;
        }

        /* internal  */onOpenSeeGuildWindowHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as SMiniGuildInfo;
            if (this._detailWindow == null) 
            {
                this._detailWindow = new GuildDetailWindow();
            }
            this._detailWindow.clear();
            this._detailWindow.show();
            Dispatcher.dispatchEvent(new DataEvent(EventName.GuildGetInfo, loc1.guildId));
            return;
        }

        /* internal  */onOpenGuildInviteListWindowHandler(arg1: DataEvent): void
        {
            if (this._inviteListWindow == null) 
            {
                this._inviteListWindow = new InviteListWindow();
            }
            this._inviteListWindow.updateListDataProvider(cache.guild.inviteList);
            this._inviteListWindow.show();
            return;
        }

        /* internal  */onOpenGuildNominateWindowHandler(arg1: DataEvent): void
        {
            var loc1=cache.guild.curSelGuildPlayer;
            if (this._nominateWindow == null) 
            {
                this._nominateWindow = new NominateWindow();
            }
            if (loc1) 
            {
                this._nominateWindow.updateTip(loc1.miniPlayer.name);
            }
            this._nominateWindow.updatePosition(cache.guild.getPositionData());
            this._nominateWindow.show();
            return;
        }

        /* internal  */onOpenGuildTaskGuideWindowHandler(arg1: DataEvent): void
        {
            if (this._taskGuideWindow == null) 
            {
                this._taskGuideWindow = new GuildTaskWindow();
            }
            this._taskGuideWindow.updateTaskNum();
            this._taskGuideWindow.show();
            return;
        }

        /* internal  */onOpenGuildContriWindowHandler(arg1: DataEvent): void
        {
            if (this._contriWindow == null) 
            {
                this._contriWindow = new GuildContibuteWindow();
            }
            this._contriWindow.updateMaxAmount(cache.guild.getAddResourcePropAmount());
            this._contriWindow.show();
            return;
        }

        /* internal  */onOpenGuildApplyListWindowHandler(arg1: DataEvent): void
        {
            if (this._applyListWindow == null) 
            {
                this._applyListWindow = new GuildApplyListWindow();
            }
            this._applyListWindow.show();
            Dispatcher.dispatchEvent(new DataEvent(EventName.GuildGetApplyList, cache.guild.myGuildInfo.guildId));
            return;
        }

        /* internal  */onOpenMassSendWindowHandler(arg1: DataEvent): void
        {
            if (this._massSendWindow == null) 
            {
                this._massSendWindow = new GuildMassSendWindow();
            }
            this._massSendWindow.show();
            return;
        }

        /* internal  */onOpenWelcomeNewMemberWindowHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as SPublicMiniPlayer;
            if (this._welcomeNewWindow == null) 
            {
                this._welcomeNewWindow = new GuildWelcomeNewMemberWindow();
            }
            this._welcomeNewWindow.updateWelcome(loc1);
            this._welcomeNewWindow.show();
            return;
        }

        /* internal  */onOpenWelcomeListWindowHandler(arg1: DataEvent): void
        {
            if (this._welcomeListWindow == null) 
            {
                this._welcomeListWindow = new GuildWelcomeListWindow();
            }
            this._welcomeListWindow.updateDataProvider(cache.guild.welcomeArray);
            this._welcomeListWindow.show();
            return;
        }

        /* internal  */onGuildCreateHandler(arg1: DataEvent): void
        {
            var loc4=false;
            var loc5=null;
            var loc1=arg1.data["option"] as EOperOption;
            var loc2=arg1.data["name"] as string;
            loc2 = StringHelper.trim(loc2);
            var loc3=arg1.data["purpose"] as string;
            if (StringHelper.getCharLength(StringHelper.trim(loc2)) == 0) 
            {
                MsgManager.showRollTipsMsg(Language.getString(57339));
                return;
            }
            if (loc1.value() == EOperOption._EOperOptionMoney) 
            {
                loc4 = false;
                loc5 = GameDefConfig.instance.getEPrictUnitName(GameConst.GuildCreateNeedUnit);
                var loc6=GameConst.GuildCreateNeedUnit;
                switch (loc6) 
                {
                    case EPrictUnit._EPriceUnitCoin:
                    {
                        if (cache.role.money.coin >= GameConst.GuildCreateNeedMoney) 
                        {
                            loc4 = true;
                        }
                        break;
                    }
                    case EPrictUnit._EPriceUnitCoinBind:
                    {
                        if (cache.role.money.coinBind + cache.role.money.coin >= GameConst.GuildCreateNeedMoney) 
                        {
                            loc4 = true;
                        }
                        break;
                    }
                    case EPrictUnit._EPriceUnitGold:
                    {
                        if (cache.role.money.gold >= GameConst.GuildCreateNeedMoney) 
                        {
                            loc4 = true;
                        }
                        break;
                    }
                    case EPrictUnit._EPriceUnitGoldBind:
                    {
                        if (cache.role.money.goldBind >= GameConst.GuildCreateNeedMoney) 
                        {
                            loc4 = true;
                        }
                        break;
                    }
                }
                if (loc4 == false) 
                {
                    MsgManager.showRollTipsMsg(Language.getStringByParam(57340, loc5));
                    Dispatcher.dispatchEvent(new DataEvent(EventName.ShopMallAutoBuyCoin, GameConst.GuildCreateNeedMoney));
                    return;
                }
            }
            GameProxy.guildProxy.createGuild(cache.role.playerInfo.playerId, loc1, loc2, loc3);
            return;
        }

        /* internal  */onGuildCreateSuccessHandler(arg1: DataEvent): void
        {
            MsgManager.showRollTipsMsg(Language.getString(57341));
            if (this._createWindow) 
            {
                this._createWindow.hide();
            }
            if (this._guildListModule) 
            {
                this._guildListModule.hide();
            }
            this._isAfterCreateSuccess = true;
            return;
        }

        /* internal  */onGuildGetHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as int;
            GameProxy.guildProxy.getGuildInfo(loc1);
            return;
        }

        /* internal  */onGuildGetInfoSuccessHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as SGuildInfo;
            if (this._detailWindow == null) 
            {
                this._detailWindow = new GuildDetailWindow();
            }
            this._detailWindow.clear();
            this._detailWindow.updateGuildInfo(loc1);
            this._detailWindow.show();
            return;
        }

        /* internal  */onGuildGetMyInfoSuccessHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as SGuildInfo;
            cache.guild.guildInfo = loc1;
            cache.guild.myGuildInfo.money = loc1.money;
            if (this._guildModule) 
            {
                this._guildModule.updateGuildInfoPanel(loc1);
            }
            return;
        }

        
        {
            GuildController.curShowType = "";
        }

        /* internal  */onGuildSearchHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data["camp"] as int;
            var loc2=arg1.data["guildName"] as string;
            var loc3=arg1.data["startIndex"] as int;
            var loc4=arg1.data["isFull"] as Boolean;
            if (!(loc1 == 0) || !(loc2 == "")) 
            {
                GuildController.isConditionSearch = true;
            }
            else 
            {
                GuildController.isConditionSearch = false;
            }
            GameProxy.guildProxy.searchGuilds(loc1, loc2, loc3, loc4);
            this._isSearch = true;
            return;
        }

        /* internal  */onGuildSearchSuccessHandler(arg1: DataEvent): void
        {
            var loc6=0;
            if (!this._isSearch) 
            {
                return;
            }
            this._isSearch = false;
            var loc1=arg1.data["guilds"] as Array<any>;
            var loc2=arg1.data["totalNum"] as int;
            var loc3=arg1.data["startIdx"] as int;
            var loc4;
            if ((loc4 = arg1.data["myRank"] as int) != 0) 
            {
                cache.guild.setMyGuildRank(loc4);
            }
            if (GuildController.isConditionSearch) 
            {
                cache.guild.guildArray = loc1;
            }
            else 
            {
                loc6 = loc3 == 0 ? 0 : (loc3 - 1);
                cache.guild.pushToGuildArrayAtIndex(loc6, loc1);
            }
            var loc5=cache.guild.guildArray;
            if (GuildController.curShowType != GuildShowType.NormalGuildList) 
            {
                this._guildModule.updateGuildDataProvider(loc5, loc2);
            }
            else 
            {
                this._guildListModule.updateGuildDataProvider(loc1, loc2);
            }
            if (loc1.length == 0) 
            {
                MsgManager.showRollTipsMsg(Language.getString(57342));
            }
            if (cache.guide.guideApplyGuild && this._guildListModule && !this._guildListModule.isHide) 
            {
                this._guildListModule.guideApplyGuild();
            }
            return;
        }

        /* internal  */onGuildUpdateInfoHandler(arg1: SPlayerGuildInfo): void
        {
            var loc2=0;
            var loc3=0;
            if (this._isAfterCreateSuccess && !cache.country.isOpenCountry) 
            {
                this.initView().show();
                this._isAfterCreateSuccess = false;
            }
            else if (arg1 && arg1.guildId == 0) 
            {
                if (this._guildModule && this._guildModule.isHide == false) 
                {
                    this._guildModule.hide();
                }
            }
            else if (this._guildListModule && this._guildListModule.isHide == false) 
            {
                this._guildListModule.hide();
            }
            if (this._guildModule) 
            {
                this._guildModule.updatePlayerGuildInfoPanel(cache.guild.myGuildInfo);
                this._guildModule.updateGuildSkillList();
            }
            var loc1=cache.guild.myGuildInfo;
            if (this._guildRaiseContributeWindow && this._guildRaiseContributeWindow.isHide == false) 
            {
                if (loc1) 
                {
                    loc2 = loc1.contribution;
                }
                this._guildRaiseContributeWindow.updateContribute(loc2);
            }
            if (this._guildPartyWindow && this._guildPartyWindow.isHide == false) 
            {
                if (loc1) 
                {
                    loc3 = loc1.contribution;
                }
                this._guildPartyWindow.updateContribute(loc3);
            }
            return;
        }

        /* internal  */onGuildApplyHandler(arg1: DataEvent): void
        {
            if (this._guildListModule != null) 
            {
                this._guildListModule.hideGuideApplyGuild();
            }
            var loc1=cache.role.playerInfo.playerId;
            var loc2=arg1.data["guildId"] as int;
            if (cache.role.entityInfo.level < GameConst.GuildJoinPlayerLevel) 
            {
                MsgManager.showRollTipsMsg(Language.getStringByParam(57343, GameConst.GuildJoinPlayerLevel));
                return;
            }
            GameProxy.guildProxy.applyGuild(loc1, loc2);
            return;
        }

        /* internal  */onGuildApplySuccessHandler(arg1: DataEvent): void
        {
            var loc2=null;
            var loc3=null;
            var loc4=0;
            var loc5=null;
            var loc6=0;
            var loc1=arg1.data as int;
            MsgManager.showRollTipsMsg(Language.getString(57344));
            if (GuildController.curShowType == GuildShowType.NormalGuildList) 
            {
                if (this._guildListModule) 
                {
                    loc2 = this._guildListModule.guildListPanel.tileList;
                    loc3 = loc2.dataProvider.toArray();
                    loc6 = 0;
                    while (loc6 < loc3.length) 
                    {
                        loc5 = loc3[loc6] as SMiniGuildInfo;
                        if (loc1 == loc5.guildId) 
                        {
                            loc4 = loc6;
                            break;
                        }
                        ++loc6;
                    }
                    loc5.apply = true;
                    loc2.dataProvider.replaceItemAt(loc5, loc4);
                    loc2.invalidateItemAt(loc4);
                }
            }
            return;
        }

        /* internal  */onGuildCancelApplyHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data["guildId"] as int;
            GameProxy.guildProxy.cancelApply(loc1);
            return;
        }

        /* internal  */onGuildCancelApplySuccessHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data["guildId"] as int;
            MsgManager.showRollTipsMsg(Language.getString(57345));
            return;
        }

        /* internal  */onGuildDealApplyHandler(arg1: DataEvent): void
        {
            var loc1=0;
            var loc2=arg1.data["toPlayerId"] as int;
            var loc3=arg1.data["oper"] as Boolean;
            GameProxy.guildProxy.dealApply(loc1, loc2, loc3);
            return;
        }

        /* internal  */onGuildDealApplySuccessHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as Boolean;
            if (loc1) 
            {
                MsgManager.showRollTipsMsg(Language.getString(57346));
            }
            else 
            {
                MsgManager.showRollTipsMsg(Language.getString(57347));
            }
            Dispatcher.dispatchEvent(new DataEvent(EventName.GuildGetApplyList, cache.guild.myGuildInfo.guildId));
            return;
        }

        /* internal  */onGuildGetApplyListHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as int;
            GameProxy.guildProxy.getApplyList(loc1);
            return;
        }

        /* internal  */onGuildGetApplyListSuccessHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as Array<any>;
            this._applyListWindow.updateListData(loc1);
            return;
        }

        /* internal  */onGuildGetPlayerListHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as int;
            GameProxy.guildProxy.getGuildPlayerList(loc1);
            return;
        }

        /* internal  */onGuildGetPlayerListSuccessHandler(arg1: DataEvent): void
        {
            var loc2=null;
            var loc3=false;
            var loc1=arg1.data as Array<any>;
            cache.guild.memberList = loc1;
            if (this._guildModule) 
            {
                this._guildModule.updateMemListPanelProvider(loc1);
                loc2 = cache.guild.memSortType;
                loc3 = cache.guild.isOnlyOnline;
                Dispatcher.dispatchEvent(new DataEvent(GuildEventName.SortMember, {"sortType": loc2, "isOnlyOnline": loc3}));
                if (this._isAfterAutoSelectMember) 
                {
                    this._isAfterAutoSelectMember = false;
                    this._guildModule.selectMemberByPlayerId(this._autoSelectPlayerId);
                }
            }
            return;
        }

        /* internal  */onSortMemberHandler(arg1: DataEvent): void
        {
            var loc1=null;
            var loc2=false;
            var loc3=null;
            if (this._guildModule) 
            {
                loc1 = arg1.data["sortType"] as string;
                loc2 = arg1.data["isOnlyOnline"] as Boolean;
                loc3 = cache.guild.getSortedMemberArray(loc1, loc2);
                this._guildModule.updateMemListPanelProvider(loc3);
                cache.guild.memSortType = loc1;
                cache.guild.isOnlyOnline = loc2;
            }
            return;
        }

        /* internal  */onGuildInviteHandler(arg1: DataEvent): void
        {
            var loc1=0;
            var loc2=arg1.data["toPlayerId"] as int;
            GameProxy.guildProxy.invitePlayer(loc1, loc2);
            return;
        }

        /* internal  */onGuildInviteSuccessHandler(arg1: DataEvent): void
        {
            MsgManager.showRollTipsMsg(Language.getString(57348));
            return;
        }

        /* internal  */onGuildDealInviteHandler(arg1: DataEvent): void
        {
            var loc1=0;
            var loc2=arg1.data["guildId"] as int;
            var loc3=arg1.data["oper"] as Boolean;
            GameProxy.guildProxy.dealInvite(loc1, loc2, loc3);
            return;
        }

        /* internal  */onGuildDealInviteSuccessHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data["guildId"] as int;
            var loc2=arg1.data["oper"] as Boolean;
            if (loc2) 
            {
                if (this._guildListModule) 
                {
                    this._guildListModule.hide();
                }
                if (this._inviteListWindow) 
                {
                    this._inviteListWindow.hide();
                }
                cache.guild.inviteList = [];
                if (!cache.country.isOpenCountry) 
                {
                    this.view.show();
                }
                MsgManager.showRollTipsMsg(Language.getString(57349));
            }
            else 
            {
                cache.guild.delInviteByGuildId(loc1);
                this._inviteListWindow.updateListDataProvider(cache.guild.inviteList);
                delete InviteGuildRender.dealDict[loc1];
                MsgManager.showRollTipsMsg(Language.getString(57350));
            }
            return;
        }

        /* internal  */onGuildGuildMemberOperHandler(arg1: DataEvent): void
        {
            var loc1=0;
            var loc2=arg1.data["toPlayerId"] as int;
            var loc3=arg1.data["toPosition"] as EGuildPosition;
            GameProxy.guildProxy.memberOper(loc1, loc2, loc3);
            return;
        }

        /* internal  */onGuildMemberOperSuccessHandler(arg1: DataEvent): void
        {
            return;
        }

        /* internal  */onGuildChangePurposeHandler(arg1: DataEvent): void
        {
            var loc1=0;
            var loc2=arg1.data as string;
            GameProxy.guildProxy.changeGuildPurpose(loc1, loc2);
            return;
        }

        /* internal  */onGuildChangePurposeSuccessHandler(arg1: DataEvent): void
        {
            MsgManager.showRollTipsMsg(Language.getString(57351));
            return;
        }

        /* internal  */onGuildChangeYYQQHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data["option"] as EOperOption;
            var loc2=arg1.data["number"] as string;
            GameProxy.guildProxy.changeYYQQ(loc1, loc2);
            return;
        }

        /* internal  */onGuildChangeYYQQSuccessHandler(arg1: DataEvent): void
        {
            MsgManager.showRollTipsMsg(Language.getString(57352));
            return;
        }

        /* internal  */onGuildKickOutHandler(arg1: DataEvent): void
        {
            var dataEvent: DataEvent;
            var guildPlayer: SGuildPlayer;
            var myGuildInfo: SPlayerGuildInfo;
            var name: string;
            var htmlContent: string;
            var onClickHandler: Function;

            var loc1;
            guildPlayer = null;
            name = null;
            htmlContent = null;
            dataEvent = arg1;
            guildPlayer = dataEvent.data as SGuildPlayer;
            myGuildInfo = cache.guild.myGuildInfo;
            if (guildPlayer && myGuildInfo) 
            {
                if (myGuildInfo.position > guildPlayer.position) 
                {
                    onClickHandler = (arg1: int): void
                    {
                        if (arg1 == Alert.OK) 
                        {
                            GameProxy.guildProxy.memberOper(0, guildPlayer.miniPlayer.entityId.id, EGuildPosition.convert(EGuildPosition._EGuildNotMember));
                            Alert.resetToDefault();
                        }
                        return;
                    }
                    name = HTMLUtil.addColor(guildPlayer.miniPlayer.name, "#ff5b5b");
                    htmlContent = Language.getStringByParam(57353, name);
                    Alert.show(htmlContent, null, Alert.OK | Alert.CANCEL, null, onClickHandler);
                }
                else 
                {
                    MsgManager.showRollTipsMsg(Language.getString(57354));
                }
            }
            return;
        }

        /* internal  */onGuildKickOutSuccessHandler(arg1: DataEvent): void
        {
            Dispatcher.dispatchEvent(new DataEvent(EventName.GuildGetPlayerList, cache.guild.myGuildInfo.guildId));
            MsgManager.showRollTipsMsg(Language.getString(57355));
            return;
        }

        /* internal  */onGuildNominateHandler(arg1: DataEvent): void
        {
            var dataEvent: DataEvent;
            var guildPlayer: SGuildPlayer;
            var toPosition: int;
            var toPositionName: string;
            var myGuildInfo: SPlayerGuildInfo;
            var htmlContent: string;
            var tip: string;
            var onClickHandler: Function;

            var loc1;
            guildPlayer = null;
            toPosition = 0;
            htmlContent = null;
            tip = null;
            dataEvent = arg1;
            guildPlayer = dataEvent.data["toGuildPlayer"] as SGuildPlayer;
            toPosition = dataEvent.data["toPosition"] as int;
            toPositionName = GameDefConfig.instance.getPositionName(toPosition);
            myGuildInfo = cache.guild.myGuildInfo;
            if (guildPlayer && myGuildInfo) 
            {
                if (myGuildInfo.position >= guildPlayer.position) 
                {
                    onClickHandler = (arg1: int): void
                    {
                        if (arg1 == Alert.OK) 
                        {
                            GameProxy.guildProxy.memberOper(0, guildPlayer.miniPlayer.entityId.id, new EGuildPosition(toPosition));
                            Alert.resetToDefault();
                        }
                        return;
                    }
                    if (guildPlayer.position == toPosition) 
                    {
                        MsgManager.showRollTipsMsg(Language.getString(57356) + toPositionName);
                        return;
                    }
                    htmlContent = Language.getStringByParam(57357, guildPlayer.miniPlayer.name, toPositionName);
                    tip = "";
                    if (toPosition != EGuildPosition._EGuildDeputyLeader) 
                    {
                        if (toPosition == EGuildPosition._EGuildPresbyter) 
                        {
                            tip = Language.getString(57385);
                        }
                    }
                    else 
                    {
                        tip = Language.getString(57384);
                    }
                    htmlContent = htmlContent + tip;
                    Alert.show(htmlContent, null, Alert.OK | Alert.CANCEL, null, onClickHandler);
                }
                else 
                {
                    MsgManager.showRollTipsMsg(Language.getString(57358));
                }
            }
            return;
        }

        /* internal  */onGuildNominateSuccessHandler(arg1: DataEvent): void
        {
            Dispatcher.dispatchEvent(new DataEvent(EventName.GuildGetPlayerList, cache.guild.myGuildInfo.guildId));
            MsgManager.showRollTipsMsg(Language.getString(57359));
            return;
        }

        /* internal  */onGuildQuitHandler(arg1: DataEvent): void
        {
            var dataEvent: DataEvent;
            var htmlContent: string;
            var onClickHandler: Function;

            var loc1;
            onClickHandler = null;
            dataEvent = arg1;
            onClickHandler = (arg1: int): void
            {
                if (arg1 == Alert.OK) 
                {
                    GameProxy.guildProxy.memberOper(0, cache.role.playerInfo.playerId, EGuildPosition.convert(EGuildPosition._EGuildNotMember));
                    Alert.resetToDefault();
                }
                return;
            }
            htmlContent = Language.getString(57360);
            Alert.show(htmlContent, null, Alert.OK | Alert.CANCEL, null, onClickHandler);
            return;
        }

        /* internal  */onGuildQuitSuccessHandler(arg1: DataEvent): void
        {
            if (this._guildModule) 
            {
                this._guildModule.hide();
            }
            MsgManager.showRollTipsMsg(Language.getString(57361));
            this.clearGuildPartyInfo();
            return;
        }

        /* internal  */onGuildDisbandHandler(arg1: DataEvent): void
        {
            var dataEvent: DataEvent;
            var myGuildInfo: SPlayerGuildInfo;
            var htmlContent: string;
            var onClickHandler: Function;

            var loc1;
            htmlContent = null;
            dataEvent = arg1;
            myGuildInfo = cache.guild.myGuildInfo;
            if (myGuildInfo) 
            {
                if (myGuildInfo.position != EGuildPosition._EGuildLeader) 
                {
                    MsgManager.showRollTipsMsg(Language.getString(57363));
                }
                else 
                {
                    onClickHandler = (arg1: int): void
                    {
                        if (arg1 == Alert.OK) 
                        {
                            GameProxy.guildProxy.disbandGuild();
                            Alert.resetToDefault();
                        }
                        return;
                    }
                    htmlContent = Language.getStringByParam(57362, myGuildInfo.guildName);
                    Alert.show(htmlContent, null, Alert.OK | Alert.CANCEL, null, onClickHandler);
                }
            }
            return;
        }

        /* internal  */onGuildDisbandSuccessHandler(arg1: DataEvent): void
        {
            if (this._guildModule) 
            {
                this._guildModule.hide();
            }
            MsgManager.showRollTipsMsg(Language.getString(57364));
            this.clearGuildPartyInfo();
            return;
        }

        /* internal  */onGuildApplyPlayersGuildHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as int;
            GameProxy.guildProxy.applyPlayersGuild(loc1);
            return;
        }

        /* internal  */onGuildApplyPlayersGuildSuccessHandler(arg1: DataEvent): void
        {
            MsgManager.showRollTipsMsg(Language.getString(57365));
            return;
        }

        /* internal  */onGuildPushInviteInfoHandler(arg1: Object): void
        {
            if (this._guildListModule) 
            {
                HighlightManager.instance.glowEffectButton(this._guildListModule.inviteBtn, true);
            }
            MsgManager.showRollTipsMsg(Language.getString(57366));
            return;
        }

        /* internal  */onGuildNewApplyHandler(arg1: SGuildApplyNum): void
        {
            var loc1=false;
            if (arg1) 
            {
                loc1 = arg1.num > 0;
                Dispatcher.dispatchEvent(new DataEvent(EventName.HighlightGameUI, {"type":"Navbar", "name": Guild, "isGlow": loc1}));
                cache.guild.hasNewApply = loc1;
            }
            return;
        }

        /* internal  */onGuildWelcomeHandler(arg1: Object): void
        {
            return;
        }

        /* internal  */onGuildNewMemberHandler(arg1: SPublicMiniPlayer): void
        {
            var loc1=!PulseSharedObject.isTodayNotTips("GuildWelcomeNew");
            if (loc1) 
            {
                if (arg1) 
                {
                    Dispatcher.dispatchEvent(new DataEvent(GuildEventName.OpenWelcomeNewMemberWindow, arg1));
                }
            }
            return;
        }

        /* internal  */onGuildUpdateHandler(arg1: DataEvent): void
        {
            GameProxy.guildProxy.updateGuild();
            return;
        }

        /* internal  */onGuildUpdateSuccessHandler(arg1: DataEvent): void
        {
            MsgManager.showRollTipsMsg(Language.getString(57367));
            Dispatcher.dispatchEvent(new DataEvent(EventName.GuildGetInfo, 0));
            return;
        }

        /* internal  */onGuildDonateMoneyHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data["option"] as EOperOption;
            var loc2=arg1.data["num"] as int;
            GameProxy.guildProxy.donateMoney(loc1, loc2);
            return;
        }

        /* internal  */onGuildDonateMoneySuccessHandler(arg1: DataEvent): void
        {
            MsgManager.showRollTipsMsg(Language.getString(57368));
            return;
        }

        /* internal  */onGuildSendMailHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data["title"] as string;
            var loc2=arg1.data["content"] as string;
            GameProxy.guildProxy.guildMail(loc1, loc2);
            return;
        }

        /* internal  */onGuildSendMailSuccessHandler(arg1: DataEvent): void
        {
            this._massSendWindow.clear();
            MsgManager.showRollTipsMsg(Language.getString(57369));
            return;
        }

        /* internal  */onGuildSendChatHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as string;
            GameProxy.chatProxy.SendMessage(EChatType._EChatTypeGuildPrivate, loc1);
            return;
        }

        /* internal  */onGuildSendChatSuccessHandler(arg1: DataEvent): void
        {
            this._massSendWindow.clear();
            MsgManager.showRollTipsMsg(Language.getString(57369));
            return;
        }

        /* internal  */onGuildSendWelcomeHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data["option"] as EOperOption;
            var loc2=arg1.data["toPlayerName"] as string;
            GameProxy.guildProxy.guildWelcome(loc1, loc2);
            return;
        }

        /* internal  */onGuildSendWelcomeSuccessHandler(arg1: DataEvent): void
        {
            MsgManager.showRollTipsMsg(Language.getString(57370));
            this._welcomeNewWindow.hide();
            return;
        }

        /* internal  */onPlayerTopListUpdate(arg1: Object): void
        {
            (this.view as GuildModule).updateGuildWarPlayerScore(cache.guildWar.myTopList);
            return;
        }

        /* internal  */onGuildTopListUpdate(arg1: Object): void
        {
            (this.view as GuildModule).updateGuildWarGuildTopList(cache.guildWar.guildTopList, cache.guildWar.myGuildTopList);
            return;
        }

        /* internal  */onAutoSelectedMemberHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as int;
            Dispatcher.dispatchEvent(new DataEvent(EventName.OpenGuildWindow, 1));
            this._autoSelectPlayerId = loc1;
            this._isAfterAutoSelectMember = true;
            return;
        }

        public get guildModule(): IGuildModule
        {
            return this._guildModule;
        }

        public isHasApplyGuild(): Boolean
        {
            if (this._guildListModule) 
            {
                return this._guildListModule.isHasAbleApplyGuild();
            }
            return false;
        }

        /* internal  */onPackbagChangeHandler(arg1: Object): void
        {
            if (this._contriWindow && this._contriWindow.isHide == false) 
            {
                this._contriWindow.resetMaxAmount();
            }
            return;
        }

        /* internal  */onGuildUpdateNameHandler(arg1: DataEvent): void
        {
            var loc3=null;
            var loc4=null;
            var loc1=arg1.data as string;
            var loc2=cache.guild.myGuildInfo;
            if (loc2 && loc2.position == EGuildPosition._EGuildLeader) 
            {
                if (StringHelper.getCharLength(StringHelper.trim(loc1)) == 0) 
                {
                    MsgManager.showRollTipsMsg(Language.getString(57339));
                    return;
                }
                loc3 = new RegExp("\\*", "gi");
                if ((loc4 = FilterText.instance.getFilterStr(loc1.replace(loc3, ""))).indexOf("*") != -1) 
                {
                    MsgManager.showRollTipsMsg(Language.getString(57391));
                    return;
                }
                GameProxy.guildProxy.updateGuildName(loc1);
            }
            else 
            {
                MsgManager.showRollTipsMsg(Language.getString(57390));
                return;
            }
            return;
        }

        /* internal  */onGuildUpdateNameSuccessHandler(arg1: DataEvent): void
        {
            MsgManager.showRollTipsMsg(Language.getString(57387));
            return;
        }

        /* internal  */onGuildUpgradeRoomHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as Function;
            GameProxy.guildProxy.upgradeGuildHouse(loc1);
            return;
        }

        /* internal  */onGuildImpeachWindowOpenHandler(arg1: DataEvent): void
        {
            if (this._impeachWindow == null) 
            {
                this._impeachWindow = new GuildImpeachWindow();
            }
            this._impeachWindow.show();
            return;
        }

        /* internal  */onGuildGetCanImpeachHandler(arg1: DataEvent): void
        {
            GameProxy.guildProxy.getImpeachStatus();
            return;
        }

        /* internal  */onGuildGetCanImpeachSuccessHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as Boolean;
            if (this._impeachWindow) 
            {
                this._impeachWindow.updateImpeachBtn(loc1);
            }
            return;
        }

        /* internal  */onGuildImpeachLeaderHandler(arg1: DataEvent): void
        {
            GameProxy.guildProxy.impeachGuildLeader();
            return;
        }

        /* internal  */onGuildImpeachLeaderSuccessHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as Boolean;
            if (loc1) 
            {
                MsgManager.showRollTipsMsg(Language.getString(57412));
                if (this._impeachWindow) 
                {
                    this._impeachWindow.hide();
                }
            }
            return;
        }

        /* internal  */onGuildRefuteImpeachHandler(arg1: DataEvent): void
        {
            GameProxy.guildProxy.antiImpeach();
            return;
        }

        /* internal  */onGuildRefuteImpeachSuccessHandler(arg1: DataEvent): void
        {
            if (this._impeachIconView && this._impeachIconView.isHide == false) 
            {
                this._impeachIconView.hide();
            }
            if (this._refuteImpeachWindow && this._refuteImpeachWindow.isHide == false) 
            {
                this._refuteImpeachWindow.hide();
            }
            MsgManager.showRollTipsMsg(Language.getString(57413));
            return;
        }

        /* internal  */onGuildImpeachLeaderCommandHandler(arg1: SGuildLeaderImpeach): void
        {
            var loc1=arg1.endDate;
            var loc2=ClockManager.instance.nowDate;
            var loc3;
            if ((loc3 = (loc1.time - loc2.time) / 1000) >= 0) 
            {
                if (this._impeachIconView == null) 
                {
                    this._impeachIconView = new GuildImpeachIconView();
                }
                this._impeachIconView.updateLeftTime(loc3);
                this._impeachIconView.impeach = arg1;
                this._impeachIconView.show();
            }
            cache.guild.isInImpeaching = true;
            return;
        }

        /* internal  */onGuildLeaderImpeachEndHandler(arg1: Object): void
        {
            cache.guild.isInImpeaching = false;
            if (this._impeachIconView) 
            {
                this._impeachIconView.hide();
            }
            if (this._refuteImpeachWindow) 
            {
                this._refuteImpeachWindow.hide();
            }
            if (this._impeachWindow) 
            {
                this._impeachWindow.hide();
            }
            return;
        }

        /* internal  */onGuildRefuteImpeachWindowOpenHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as SGuildLeaderImpeach;
            if (this._refuteImpeachWindow == null) 
            {
                this._refuteImpeachWindow = new GuildRefuteImpeachWindow();
            }
            this._refuteImpeachWindow.updateByGuildImpeach(loc1);
            this._refuteImpeachWindow.show();
            return;
        }

        /* internal  */onGuildPartyWindowOpenHandler(arg1: DataEvent): void
        {
            if (this._guildPartyWindow == null) 
            {
                this._guildPartyWindow = new GuildPartyWindow();
            }
            this._guildPartyWindow.show();
            return;
        }

        /* internal  */onGuildPartyJoinWindowOpenHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as SGuildPartyOpen;
            if (this._partyJoinWindow == null) 
            {
                this._partyJoinWindow = new GuildPartyJoinWindow();
            }
            this._partyJoinWindow.updateByGuildPartyOpen(loc1);
            this._partyJoinWindow.show();
            return;
        }

        /* internal  */onGuildPartyDescWindowOpenHandler(arg1: DataEvent): void
        {
            if (this._guildPartyDescWindow == null) 
            {
                this._guildPartyDescWindow = new GuildPartyDescWindow();
            }
            if (this._guildPartyWindow && this._guildPartyWindow.isHide == false) 
            {
                LayerManager.windowLayer.centerWindows(this._guildPartyWindow, this._guildPartyDescWindow);
            }
            if (this._guildRaiseContributeWindow && this._guildRaiseContributeWindow.isHide == false) 
            {
                LayerManager.windowLayer.centerWindows(this._guildRaiseContributeWindow, this._guildPartyDescWindow);
            }
            else 
            {
                this._guildPartyDescWindow.show();
            }
            return;
        }

        /* internal  */onGuildGetPartyInfoHandler(arg1: DataEvent): void
        {
            GameProxy.guildProxy.getPartyInfo();
            return;
        }

        /* internal  */onGuildGetPartyInfoSuccessHandler(arg1: DataEvent): void
        {
            var loc2=0;
            var loc1=arg1.data as GuildPartyInfo;
            if (this._guildPartyWindow) 
            {
                this._guildPartyWindow.updateByGuildPartyInfo(loc1);
            }
            if (this._guildRaiseContributeWindow) 
            {
                this._guildRaiseContributeWindow.updateByGuildPartyInfo(loc1);
            }
            if (GuildController.isShowRaiseAlert) 
            {
                if (cache.guild.guildPartyInfo && loc1) 
                {
                    loc2 = cache.guild.guildPartyInfo.raiseVal - loc1.raiseVal;
                    if (loc2 > 0) 
                    {
                        MsgManager.addTipText(Language.getStringByParam(57611, loc2));
                    }
                }
                GuildController.isShowRaiseAlert = false;
            }
            cache.guild.guildPartyInfo = loc1;
            return;
        }

        /* internal  */onGuildBookPartyHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data["type"] as EGuildPartyType;
            var loc2=arg1.data["hour"] as int;
            GameProxy.guildProxy.bookParty(loc1, loc2);
            return;
        }

        /* internal  */onGuildBookPartySuccessHandler(arg1: DataEvent): void
        {
            GuildController.isShowRaiseAlert = true;
            MsgManager.showRollTipsMsg(Language.getString(57452));
            Dispatcher.dispatchEvent(new DataEvent(EventName.GuildGetPartyInfo));
            return;
        }

        /* internal  */onGuildPartyOpenCommandHandler(arg1: SGuildPartyOpen): void
        {
            var loc1=null;
            var loc2=null;
            var loc3=0;
            if (cache.guild.isInSelfManorMap()) 
            {
                if (this._guildPartyResultPanel == null) 
                {
                    this._guildPartyResultPanel = new GuildPartyResultPanel();
                }
                this._guildPartyResultPanel.updateByGuildPartyOpen(arg1);
                this._guildPartyResultPanel.show();
                if (this._guildPartyIconView) 
                {
                    this._guildPartyIconView.hide();
                }
            }
            else 
            {
                loc1 = arg1.endDt;
                loc2 = ClockManager.instance.nowDate;
                loc3 = (loc1.time - loc2.time) / 1000;
                if (this._guildPartyIconView == null) 
                {
                    this._guildPartyIconView = new GuildPartyIconView();
                }
                this._guildPartyIconView.partyOpen = arg1;
                this._guildPartyIconView.updateLeftTime(loc3);
                this._guildPartyIconView.show();
                if (this._guildPartyResultPanel) 
                {
                    this._guildPartyResultPanel.hide();
                }
            }
            return;
        }

        /* internal  */onGuildPartyCloseCommandHandler(arg1: Object): void
        {
            this.clearGuildPartyInfo();
            return;
        }

        /* internal  */onGuildPartyHotCommandHandler(arg1: SGuildPartyHot): void
        {
            if (this._guildPartyResultPanel) 
            {
                this._guildPartyResultPanel.updateMood(arg1.degree);
            }
            return;
        }

        /* internal  */onRoleExpAddHandler(arg1: ExpAddInfo): void
        {
            if (arg1) 
            {
                if (arg1.code != UpdateCode.EUpdateCodeGuildParty) 
                {
                    if (arg1.code != UpdateCode.EUpdateCodeGuildPartyFood) 
                    {
                        if (arg1.code == UpdateCode.EUpdateCodeGuildTreeWorm) 
                        {
                            cache.guild.guildTreeWormTotalExp = cache.guild.guildTreeWormTotalExp + arg1.valueAdd;
                            if (this._guildTreeWormPanel) 
                            {
                                this._guildTreeWormPanel.updateExp(cache.guild.guildTreeWormTotalExp);
                            }
                            NetDispatcher.dispatchCmd(ServerCommand.RoleSingleAttributeChange, new AttributeValue(AttributeTextType.experience, true, arg1.valueAdd));
                        }
                    }
                    else 
                    {
                        MsgManager.showRollTipsMsg(Language.getStringByParam(57455, arg1.valueAdd));
                    }
                }
                else 
                {
                    cache.guild.guildPartyTotalExp = cache.guild.guildPartyTotalExp + arg1.valueAdd;
                    if (this._guildPartyResultPanel) 
                    {
                        this._guildPartyResultPanel.updateExp(cache.guild.guildPartyTotalExp);
                    }
                }
            }
            return;
        }

        /* internal  */clearGuildPartyInfo(): void
        {
            if (this._guildPartyWindow) 
            {
                this._guildPartyWindow.hide();
                this._guildPartyWindow = null;
            }
            if (this._guildPartyIconView) 
            {
                this._guildPartyIconView.hide();
            }
            if (this._guildPartyResultPanel) 
            {
                this._guildPartyResultPanel.hide();
            }
            if (this._guildPartyDescWindow) 
            {
                this._guildPartyDescWindow.hide();
            }
            if (this._partyJoinWindow) 
            {
                this._partyJoinWindow.hide();
            }
            cache.guild.guildPartyOpen = null;
            cache.guild.partyHot = null;
            cache.guild.guildPartyTotalExp = 0;
            return;
        }

        /* internal  */tallyUpGuildParty(): void
        {
            var totalExp: int;
            var totalAura: int;
            var totalContri: int;
            var typeName: string;
            var onBtnClickHandler: Function;

            var loc1;
            totalExp = 0;
            typeName = null;
            totalExp = cache.guild.guildPartyTotalExp;
            totalAura = cache.guild.guildPartyTotalAura;
            totalContri = cache.guild.guildPartyTotalContribute;
            if (cache.guild.guildPartyOpen && (totalExp > 0 || totalAura > 0)) 
            {
                onBtnClickHandler = (arg1: int): void
                {
                    if (arg1 == Alert.OK) 
                    {
                        Dispatcher.dispatchEvent(new DataEvent(EventName.ShowAddExpEffect, totalExp));
                        Alert.resetToDefault();
                    }
                    return;
                }
                typeName = GuildUtil.getGuildPartyTypeName(cache.guild.guildPartyOpen.type.__value);
                Alert.show(Language.getStringByParam(57454, typeName, totalExp, totalAura, totalContri), null, Alert.OK, null, onBtnClickHandler);
                this.clearGuildPartyExp();
            }
            return;
        }

        /* internal  */clearGuildPartyExp(): void
        {
            cache.guild.guildPartyTotalExp = 0;
            cache.guild.guildPartyTotalAura = 0;
            if (this._guildPartyResultPanel) 
            {
                this._guildPartyResultPanel.updateExp(0);
                this._guildPartyResultPanel.updateAura(0);
                this._guildPartyResultPanel.updateContri(0);
            }
            return;
        }

        /* internal  */onGuildPartyRaiseContributeOpenHandler(arg1: DataEvent): void
        {
            if (this._guildRaiseContributeWindow == null) 
            {
                this._guildRaiseContributeWindow = new GuildRaiseContributeWindow();
            }
            this._guildRaiseContributeWindow.show();
            return;
        }

        /* internal  */onGuildPartyRaiseContributeHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as int;
            GameProxy.guildProxy.raiseContribution(loc1);
            return;
        }

        /* internal  */onGuildPartyRaiseContributeSuccessHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data["raiseVal"] as int;
            var loc2=arg1.data["contribite"] as int;
            if (this._guildRaiseContributeWindow) 
            {
                this._guildRaiseContributeWindow.updateByRaiseValue(loc1);
            }
            if (this._guildPartyWindow && this._guildPartyWindow.isHide == false) 
            {
                this._guildPartyWindow.updateRaise(loc1);
            }
            if (loc2 > 0) 
            {
                MsgManager.showRollTipsMsg(Language.getString(57368));
            }
            return;
        }

        /* internal  */onGuildPartyGetDiscountHandler(arg1: DataEvent): void
        {
            GameProxy.guildProxy.getPartyDiscount();
            return;
        }

        /* internal  */onGuildPartyGetDiscountSuccessHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as GuildPartyDiscountInfo;
            if (this._guildPartyWindow && this._guildPartyWindow.isHide == false) 
            {
                this._guildPartyWindow.updateByDiscountInfo(loc1);
            }
            return;
        }

        /* internal  */onMoneyUpdateHandler(arg1: SMoney): void
        {
            if (this._guildPartyWindow && this._guildPartyWindow.isHide == false) 
            {
                this._guildPartyWindow.updateGold(arg1.gold);
            }
            return;
        }

        private /* var */_guildModule: IGuildModule;

        private /* var */_guildListModule: IGuildListModule;

        private /* var */_createWindow: CreateGuildWindow;

        private /* var */_detailWindow: GuildDetailWindow;

        private /* var */_infoWindow: GuildInfoWindow;

        private /* var */_contriWindow: GuildContibuteWindow;

        private /* var */_inviteListWindow: InviteListWindow;

        private /* var */_nominateWindow: NominateWindow;

        private /* var */_taskGuideWindow: GuildTaskWindow;

        private /* var */_applyListWindow: GuildApplyListWindow;

        private /* var */_massSendWindow: GuildMassSendWindow;

        private /* var */_welcomeNewWindow: GuildWelcomeNewMemberWindow;

        private /* var */_welcomeListWindow: GuildWelcomeListWindow;

        private /* var */_impeachIconView: GuildImpeachIconView;

        private /* var */_refuteImpeachWindow: GuildRefuteImpeachWindow;

        private /* var */_impeachWindow: GuildImpeachWindow;

        private /* var */_guildPartyWindow: IGuildPartyModule;

        private /* var */_guildPartyDescWindow: GuildPartyDescWindow;

        private /* var */_guildPartyResultPanel: GuildPartyResultPanel;

        private /* var */_partyJoinWindow: GuildPartyJoinWindow;

        private /* var */_guildPartyIconView: GuildPartyIconView;

        private /* var */_guildRaiseContributeWindow: GuildRaiseContributeWindow;

        private /* var */_countMoneyView: GuildTreeCountMoneyView;

        private /* var */_guildTreeFightAlertWindow: GuildTreeFightAlertWindow;

        private /* var */_guildTreeFightIcon: GuildTreeFightIcon;

        private /* var */_guildCallTogetherWindow: GuildCallTogetherWindow;

        private /* var */_guildCallTogetherIcon: GuildCallTogetherIcon;

        private /* var */_welcomeIcon: WelcomeHintIcon;

        private /* var */_partyRewardWindow: GuildPartyRewardWindow;

        private /* var */_isAfterCreateSuccess: Boolean=false;

        private /* var */_isAfterAutoSelectMember: Boolean=false;

        private /* var */_autoSelectPlayerId: int;

        private /* var */_guildTreeType: int=-1;

        private /* var */_guildTreeWormPanel: GuildTreeFightPanel;

        private /* var */_isSearch: Boolean=false;

        public static /* var */isConditionSearch: Boolean;

        private static /* var */isShowRaiseAlert: Boolean;

        public static /* var */curShowType: string="";
    }
